{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "def findConv2dOutShape(H_in,W_in,conv,pool=2):\n",
    "    # get conv arguments\n",
    "    kernel_size=conv.kernel_size\n",
    "    stride=conv.stride\n",
    "    padding=conv.padding\n",
    "    dilation=conv.dilation\n",
    "\n",
    "    # Ref: https://pytorch.org/docs/stable/nn.html\n",
    "    H_out=np.floor((H_in+2*padding[0]-dilation[0]*(kernel_size[0]-1)-1)/stride[0]+1)\n",
    "    W_out=np.floor((W_in+2*padding[1]-dilation[1]*(kernel_size[1]-1)-1)/stride[1]+1)\n",
    "\n",
    "    if pool:\n",
    "        H_out/=pool\n",
    "        W_out/=pool\n",
    "    return int(H_out),int(W_out)\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self, params):\n",
    "        super(Net, self).__init__()\n",
    "    \n",
    "        C_in,H_in,W_in=params[\"input_shape\"]\n",
    "        init_f=params[\"initial_filters\"] \n",
    "        num_fc1=params[\"num_fc1\"]  \n",
    "        num_classes=params[\"num_classes\"] \n",
    "        self.dropout_rate=params[\"dropout_rate\"] \n",
    "        \n",
    "        self.conv1 = nn.Conv2d(C_in, init_f, kernel_size=3)\n",
    "        h,w=findConv2dOutShape(H_in,W_in,self.conv1)\n",
    "        \n",
    "        self.conv2 = nn.Conv2d(init_f, 2*init_f, kernel_size=3)\n",
    "        h,w=findConv2dOutShape(h,w,self.conv2)\n",
    "        \n",
    "        self.conv3 = nn.Conv2d(2*init_f, 4*init_f, kernel_size=3)\n",
    "        h,w=findConv2dOutShape(h,w,self.conv3)\n",
    "\n",
    "        self.conv4 = nn.Conv2d(4*init_f, 8*init_f, kernel_size=3)\n",
    "        h,w=findConv2dOutShape(h,w,self.conv4)\n",
    "        \n",
    "        # compute the flatten size\n",
    "        self.num_flatten=h*w*8*init_f\n",
    "        \n",
    "        self.fc1 = nn.Linear(self.num_flatten, num_fc1)\n",
    "        self.fc2 = nn.Linear(num_fc1, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.max_pool2d(x, 2, 2)\n",
    "        \n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.max_pool2d(x, 2, 2)\n",
    "\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = F.max_pool2d(x, 2, 2)\n",
    "\n",
    "        x = F.relu(self.conv4(x))\n",
    "        x = F.max_pool2d(x, 2, 2)\n",
    "        \n",
    "        x = x.view(-1, self.num_flatten)\n",
    "        \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x=F.dropout(x, self.dropout_rate)\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model parameters\n",
    "params_model={\n",
    " \"input_shape\": (3,96,96),\n",
    " \"initial_filters\": 8, \n",
    " \"num_fc1\": 100,\n",
    " \"dropout_rate\": 0.25,\n",
    " \"num_classes\": 2,\n",
    " }\n",
    "\n",
    "# initialize model\n",
    "cnn_model = Net(params_model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "path2weights=\"./models/weights.pt\"\n",
    "# load state_dict into model\n",
    "cnn_model.load_state_dict(torch.load(path2weights))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (conv1): Conv2d(3, 8, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (conv3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (conv4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (fc1): Linear(in_features=1024, out_features=100, bias=True)\n",
       "  (fc2): Linear(in_features=100, out_features=2, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set model in evaluation mode\n",
    "cnn_model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# move model to cuda/gpu device\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "    cnn_model=cnn_model.to(device) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time \n",
    "def deploy_model(model,dataset,device, num_classes=2,sanity_check=False):\n",
    "\n",
    "    len_data=len(dataset)\n",
    "    \n",
    "    # initialize output tensor on CPU: due to GPU memory limits\n",
    "    y_out=torch.zeros(len_data,num_classes)\n",
    "    \n",
    "    # initialize ground truth on CPU: due to GPU memory limits\n",
    "    y_gt=np.zeros((len_data),dtype=\"uint8\")\n",
    "    \n",
    "    # move model to device\n",
    "    model=model.to(device)\n",
    "    \n",
    "    elapsed_times=[]\n",
    "    with torch.no_grad():\n",
    "        for i in range(len_data):\n",
    "            x,y=dataset[i]\n",
    "            y_gt[i]=y\n",
    "            start=time.time()    \n",
    "            y_out[i]=model(x.unsqueeze(0).to(device))\n",
    "            elapsed=time.time()-start\n",
    "            elapsed_times.append(elapsed)\n",
    "\n",
    "            if sanity_check is True:\n",
    "                break\n",
    "\n",
    "    inference_time=np.mean(elapsed_times)*1000\n",
    "    print(\"average inference time per image on %s: %.2f ms \" %(device,inference_time))\n",
    "    return y_out.numpy(),y_gt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from PIL import Image\n",
    "from torch.utils.data import Dataset\n",
    "import pandas as pd\n",
    "import torchvision.transforms as transforms\n",
    "import os\n",
    "\n",
    "# fix torch random seed\n",
    "torch.manual_seed(0)\n",
    "\n",
    "class histoCancerDataset(Dataset):\n",
    "    def __init__(self, data_dir, transform,data_type=\"train\"):      \n",
    "    \n",
    "        # path to images\n",
    "        path2data=os.path.join(data_dir,data_type)\n",
    "\n",
    "        # get a list of images\n",
    "        self.filenames = os.listdir(path2data)\n",
    "\n",
    "        # get the full path to images\n",
    "        self.full_filenames = [os.path.join(path2data, f) for f in self.filenames]\n",
    "\n",
    "        # labels are in a csv file named train_labels.csv\n",
    "        csv_filename=data_type+\"_labels.csv\"\n",
    "        path2csvLabels=os.path.join(data_dir,csv_filename)\n",
    "        labels_df=pd.read_csv(path2csvLabels)\n",
    "\n",
    "        # set data frame index to id\n",
    "        labels_df.set_index(\"id\", inplace=True)\n",
    "\n",
    "        # obtain labels from data frame\n",
    "        self.labels = [labels_df.loc[filename[:-4]].values[0] for filename in self.filenames]\n",
    "\n",
    "        self.transform = transform\n",
    "      \n",
    "    def __len__(self):\n",
    "        # return size of dataset\n",
    "        return len(self.full_filenames)\n",
    "      \n",
    "    def __getitem__(self, idx):\n",
    "        # open image, apply transforms and return with label\n",
    "        image = Image.open(self.full_filenames[idx])  # PIL image\n",
    "        image = self.transform(image)\n",
    "        return image, self.labels[idx]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchvision.transforms as transforms\n",
    "data_transformer = transforms.Compose([transforms.ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "220025\n"
     ]
    }
   ],
   "source": [
    "data_dir = \"./data/\"\n",
    "histo_dataset = histoCancerDataset(data_dir, data_transformer, \"train\")\n",
    "print(len(histo_dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train dataset length: 176020\n",
      "validation dataset length: 44005\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import random_split\n",
    "\n",
    "len_histo=len(histo_dataset)\n",
    "len_train=int(0.8*len_histo)\n",
    "len_val=len_histo-len_train\n",
    "\n",
    "train_ds,val_ds=random_split(histo_dataset,[len_train,len_val])\n",
    "\n",
    "print(\"train dataset length:\", len(train_ds))\n",
    "print(\"validation dataset length:\", len(val_ds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average inference time per image on cuda: 0.70 ms \n",
      "(44005, 2) (44005,)\n"
     ]
    }
   ],
   "source": [
    "# deploy model \n",
    "y_out,y_gt=deploy_model(cnn_model,val_ds,device=device,sanity_check=False)\n",
    "print(y_out.shape,y_gt.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(44005,) (44005,)\n",
      "accuracy: 0.94\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# get predictions\n",
    "y_pred = np.argmax(y_out,axis=1)\n",
    "print(y_pred.shape,y_gt.shape)\n",
    "\n",
    "# compute accuracy \n",
    "acc=accuracy_score(y_pred,y_gt)\n",
    "print(\"accuracy: %.2f\" %acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deploy on CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average inference time per image on cpu: 2.24 ms \n",
      "(44005, 2) (44005,)\n"
     ]
    }
   ],
   "source": [
    "# deploy model on cpu\n",
    "device_cpu = torch.device(\"cpu\")\n",
    "y_out,y_gt=deploy_model(cnn_model,val_ds,device=device_cpu,sanity_check=False)\n",
    "print(y_out.shape,y_gt.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Inference on Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>95596b92e5066c5c52466c90b69ff089b39f2737</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>248e6738860e2ebcf6258cdc1f32f299e0c76914</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2c35657e312966e9294eac6841726ff3a748febf</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>145782eb7caa1c516acbe2eda34d9a3f31c41fd6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                         id  label\n",
       "0  0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5      0\n",
       "1  95596b92e5066c5c52466c90b69ff089b39f2737      0\n",
       "2  248e6738860e2ebcf6258cdc1f32f299e0c76914      0\n",
       "3  2c35657e312966e9294eac6841726ff3a748febf      0\n",
       "4  145782eb7caa1c516acbe2eda34d9a3f31c41fd6      0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path2csv=\"./data/test_labels.csv\"\n",
    "labels_df=pd.read_csv(path2csv)\n",
    "labels_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57458\n"
     ]
    }
   ],
   "source": [
    "data_dir = \"./data/\"\n",
    "histo_test = histoCancerDataset(data_dir, data_transformer,data_type=\"test\")\n",
    "print(len(histo_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average inference time per image on cuda: 0.69 ms \n",
      "(57458,)\n"
     ]
    }
   ],
   "source": [
    "y_test_out,_=deploy_model(cnn_model,histo_test, device, sanity_check=False)\n",
    "\n",
    "\n",
    "y_test_pred=np.argmax(y_test_out,axis=1)\n",
    "print(y_test_pred.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "image indices: [ 2732 43567 42613 52416]\n",
      "torch.Size([3, 100, 394])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torchvision import utils\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "np.random.seed(0)\n",
    "\n",
    "\n",
    "def show(img,y,color=False):\n",
    "    # convert tensor to numpy array\n",
    "    npimg = img.numpy()\n",
    "   \n",
    "    # Convert to H*W*C shape\n",
    "    npimg_tr=np.transpose(npimg, (1,2,0))\n",
    "    \n",
    "    if color==False:\n",
    "        npimg_tr=npimg_tr[:,:,0]\n",
    "        plt.imshow(npimg_tr,interpolation='nearest',cmap=\"gray\")\n",
    "    else:\n",
    "        # display images\n",
    "        plt.imshow(npimg_tr,interpolation='nearest')\n",
    "    plt.title(\"label: \"+str(y))\n",
    "    \n",
    "grid_size=4\n",
    "rnd_inds=np.random.randint(0,len(histo_test),grid_size)\n",
    "print(\"image indices:\",rnd_inds)\n",
    "\n",
    "x_grid_test=[histo_test[i][0] for i in range(grid_size)]\n",
    "y_grid_test=[y_test_pred[i] for i in range(grid_size)]\n",
    "\n",
    "x_grid_test=utils.make_grid(x_grid_test, nrow=4, padding=2)\n",
    "print(x_grid_test.shape)\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (10.0, 5)\n",
    "show(x_grid_test,y_grid_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(57458, 2)\n",
      "(57458,)\n"
     ]
    }
   ],
   "source": [
    "print(y_test_out.shape)\n",
    "cancer_preds = np.exp(y_test_out[:, 1])\n",
    "print(cancer_preds.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5</td>\n",
       "      <td>5.777897e-02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>95596b92e5066c5c52466c90b69ff089b39f2737</td>\n",
       "      <td>3.418587e-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>248e6738860e2ebcf6258cdc1f32f299e0c76914</td>\n",
       "      <td>1.615198e-08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2c35657e312966e9294eac6841726ff3a748febf</td>\n",
       "      <td>9.672046e-02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>145782eb7caa1c516acbe2eda34d9a3f31c41fd6</td>\n",
       "      <td>1.990013e-02</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                         id         label\n",
       "0  0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5  5.777897e-02\n",
       "1  95596b92e5066c5c52466c90b69ff089b39f2737  3.418587e-03\n",
       "2  248e6738860e2ebcf6258cdc1f32f299e0c76914  1.615198e-08\n",
       "3  2c35657e312966e9294eac6841726ff3a748febf  9.672046e-02\n",
       "4  145782eb7caa1c516acbe2eda34d9a3f31c41fd6  1.990013e-02"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get test id's from the sample_submission.csv \n",
    "path2sampleSub = \"./data/\"+ \"sample_submission.csv\"\n",
    "\n",
    "# read sample submission\n",
    "sample_df = pd.read_csv(path2sampleSub)\n",
    "\n",
    "# get id column\n",
    "ids_list = list(sample_df.id)\n",
    "\n",
    "# convert predictions to to list\n",
    "pred_list = [p for p in cancer_preds]\n",
    "\n",
    "# create a dict of id and prediction\n",
    "pred_dic = dict((key[:-4], value) for (key, value) in zip(histo_test.filenames, pred_list))    \n",
    "\n",
    "\n",
    "# re-order predictions to match sample submission csv \n",
    "pred_list_sub = [pred_dic[id_] for id_ in ids_list]\n",
    "\n",
    "# create convert to data frame\n",
    "submission_df = pd.DataFrame({'id':ids_list,'label':pred_list_sub})\n",
    "\n",
    "# Export to csv\n",
    "if not os.path.exists(\"./submissions/\"):\n",
    "    os.makedirs(\"submissions/\")\n",
    "    print(\"submission folder created!\")\n",
    "    \n",
    "path2submission=\"./submissions/submission.csv\"\n",
    "submission_df.to_csv(path2submission, header=True, index=False)\n",
    "submission_df.head()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
